# 如果文件不存在，创建一个基本的Retriever类用于测试
from typing import List, Dict, Any, Optional, Literal
from .embedding.factory import create_embedding_provider
from .vector_store import VectorStore
from ..core.logger import get_logger

logger = get_logger('rag.retriever')

class Retriever:
    """文档检索器"""
    
    def __init__(self):
        """初始化检索器"""
        logger.info("初始化检索器")
        self.embedding_provider = create_embedding_provider()
        self.vector_store = VectorStore(embedding_provider=self.embedding_provider)
    
    def search(self, query: str, k: int = 10, filter: Optional[Dict[str, Any]] = None, 
               search_type: Literal['basic', 'hybrid', 'adaptive'] = 'basic') -> List[str]:
        """
        搜索相关文档，支持多种检索策略
        
        Args:
            query: 查询字符串
            k: 返回结果数量
            filter: 元数据过滤条件（可选）
            search_type: 检索策略类型，可选 'basic', 'hybrid', 'adaptive'
            
        Returns:
            相关文档列表
        """
        logger.info(f"执行{search_type}文档检索，查询: {query[:100]}...")
        logger.debug(f"检索参数: query_length={len(query)}, k={k}, filter={filter}")
        
        # 根据检索类型选择不同的搜索方法
        if search_type == 'hybrid':
            results = self.vector_store.hybrid_search(query, k=k, filter=filter)
        elif search_type == 'adaptive':
            results = self.vector_store.adaptive_search(query, k=k, filter=filter)
        else:
            # 基础检索策略
            if filter:
                results = self.vector_store.similarity_search_with_metadata_filter(query, filter=filter, k=k)
            else:
                results = self.vector_store.similarity_search(query, k=k)
        
        # 提取文档内容
        documents = [doc.page_content for doc in results] if results else []
        logger.debug(f"检索完成，返回 {len(documents)} 个结果")
        return documents

    def hybrid_search(self, query: str, k: int = 10, filter: Optional[Dict[str, Any]] = None) -> List[str]:
        """
        使用混合检索策略搜索相关文档
        
        Args:
            query: 查询字符串
            k: 返回结果数量
            filter: 元数据过滤条件（可选）
            
        Returns:
            相关文档列表
        """
        logger.info(f"执行混合检索，查询: {query[:100]}...")
        
        # 调用向量存储的混合检索方法
        results = self.vector_store.hybrid_search(query, k=k, filter=filter)
        
        # 提取文档内容
        documents = [doc.page_content for doc in results] if results else []
        logger.debug(f"混合检索完成，返回 {len(documents)} 个结果")
        return documents

    def adaptive_search(self, query: str, k: int = 10, filter: Optional[Dict[str, Any]] = None) -> List[str]:
        """
        使用自适应检索策略搜索相关文档
        
        Args:
            query: 查询字符串
            k: 返回结果数量
            filter: 元数据过滤条件（可选）
            
        Returns:
            相关文档列表
        """
        logger.info(f"执行自适应检索，查询: {query[:100]}...")
        
        # 调用向量存储的自适应检索方法
        results = self.vector_store.adaptive_search(query, k=k, filter=filter)
        
        # 提取文档内容
        documents = [doc.page_content for doc in results] if results else []
        logger.debug(f"自适应检索完成，返回 {len(documents)} 个结果")
        return documents

    def search_with_metadata_filter(self, query: str, filter: Dict[str, Any], k: int = 10) -> List[str]:
        """
        使用元数据过滤条件搜索相关文档
        
        Args:
            query: 查询字符串
            filter: 元数据过滤条件
            k: 返回结果数量
            
        Returns:
            过滤后的相关文档列表
        """
        logger.info(f"执行带元数据过滤的文档检索，查询: {query[:100]}...")
        logger.info(f"元数据过滤条件: {filter}")
        logger.debug(f"检索参数: query_length={len(query)}, k={k}")
        
        # 调用向量存储的带过滤搜索方法
        results = self.vector_store.similarity_search_with_metadata_filter(query, filter=filter, k=k)
        
        # 提取文档内容
        documents = [doc.page_content for doc in results] if results else []
        logger.debug(f"带元数据过滤的检索完成，返回 {len(documents)} 个结果")
        return documents